/**
 * 设备用户绑定和权限控制功能测试（模拟测试）
 * 测试场景：
 * 1. 用户A启用设备后，用户B尝试结束设备使用应被拒绝
 * 2. 用户A启用设备后，用户B尝试延时设备使用应被拒绝
 * 3. 用户A启用设备后，用户A可以正常结束和延时设备使用
 */

class MockDeviceStatusManager {
    constructor() {
        this.deviceStatuses = new Map();
    }

    async startDeviceUsage(deviceId, duration, orderId, userId) {
        console.log(`启动设备使用: 设备${deviceId}, 用户${userId}, 时长${duration}分钟`);
        this.deviceStatuses.set(deviceId, {
            deviceId,
            status: 'IN_USE',
            userId,
            orderId,
            duration,
            startTime: new Date(),
            endTime: new Date(Date.now() + duration * 60 * 1000)
        });
        return { success: true };
    }

    async checkDevicePermission(deviceId, userId) {
        const status = this.deviceStatuses.get(deviceId);
        
        if (!status) {
            return { allowed: true, message: '设备未在使用中' };
        }
        
        if (status.status !== 'IN_USE') {
            return { allowed: true, message: '设备未在使用中' };
        }
        
        if (status.userId === userId) {
            return { allowed: true, message: '用户有权限操作设备' };
        }
        
        return { 
            allowed: false, 
            message: `设备正在使用中，当前用户: ${status.userId}，请求用户: ${userId}` 
        };
    }

    async extendDeviceUsage(deviceId, extendMinutes, orderId, userId) {
        const permission = await this.checkDevicePermission(deviceId, userId);
        
        if (!permission.allowed) {
            throw new Error(`无权限延时设备: ${permission.message}`);
        }
        
        const status = this.deviceStatuses.get(deviceId);
        if (status) {
            status.endTime = new Date(status.endTime.getTime() + extendMinutes * 60 * 1000);
            console.log(`设备${deviceId}延时${extendMinutes}分钟成功`);
        }
        
        return { success: true };
    }

    async endDeviceUsage(deviceId) {
        this.deviceStatuses.delete(deviceId);
        console.log(`设备${deviceId}使用结束`);
        return { success: true };
    }

    async getDeviceRealTimeStatus(deviceId) {
        return this.deviceStatuses.get(deviceId) || { status: 'IDLE' };
    }
}

class DevicePermissionTest {
    constructor() {
        this.deviceStatusManager = new MockDeviceStatusManager();
        this.testDeviceId = 'test_device_001';
        this.userA = 'user_a_001';
        this.userB = 'user_b_002';
    }

    /**
     * 运行所有测试
     */
    async runAllTests() {
        console.log('=== 开始设备权限控制测试 ===');
        
        try {
            await this.testUserBindingOnDeviceStart();
            await this.testUnauthorizedUserCannotEndDevice();
            await this.testUnauthorizedUserCannotExtendDevice();
            await this.testAuthorizedUserCanControlDevice();
            
            console.log('\n✅ 所有测试通过！');
        } catch (error) {
            console.error('\n❌ 测试失败:', error.message);
            throw error;
        }
    }

    /**
     * 测试设备启用时的用户绑定
     */
    async testUserBindingOnDeviceStart() {
        console.log('\n1. 测试设备启用时的用户绑定...');
        
        // 模拟用户A启用设备
        const orderId = 'test_order_001';
        const duration = 30; // 30分钟
        
        await this.deviceStatusManager.startDeviceUsage(this.testDeviceId, duration, orderId, this.userA);
        
        // 检查设备状态是否包含用户信息
        const status = await this.deviceStatusManager.getDeviceRealTimeStatus(this.testDeviceId);
        
        if (status.userId !== this.userA) {
            throw new Error(`设备状态中的用户ID不正确，期望: ${this.userA}, 实际: ${status.userId}`);
        }
        
        console.log('✅ 设备启用时用户绑定成功');
    }

    /**
     * 测试未授权用户无法结束设备使用
     */
    async testUnauthorizedUserCannotEndDevice() {
        console.log('\n2. 测试未授权用户无法结束设备使用...');
        
        // 用户B尝试检查设备权限
        const permission = await this.deviceStatusManager.checkDevicePermission(this.testDeviceId, this.userB);
        
        if (permission.allowed) {
            throw new Error('用户B不应该有权限操作设备');
        }
        
        console.log('✅ 未授权用户被正确拒绝:', permission.message);
    }

    /**
     * 测试未授权用户无法延时设备使用
     */
    async testUnauthorizedUserCannotExtendDevice() {
        console.log('\n3. 测试未授权用户无法延时设备使用...');
        
        try {
            // 用户B尝试延时设备
            await this.deviceStatusManager.extendDeviceUsage(this.testDeviceId, 15, 'test_extend_order', this.userB);
            throw new Error('用户B不应该能够延时设备');
        } catch (error) {
            if (error.message.includes('不应该能够延时')) {
                throw error;
            }
            console.log('✅ 未授权用户延时被正确拒绝:', error.message);
        }
    }

    /**
     * 测试授权用户可以正常控制设备
     */
    async testAuthorizedUserCanControlDevice() {
        console.log('\n4. 测试授权用户可以正常控制设备...');
        
        // 用户A检查权限
        const permission = await this.deviceStatusManager.checkDevicePermission(this.testDeviceId, this.userA);
        
        if (!permission.allowed) {
            throw new Error(`用户A应该有权限操作设备: ${permission.message}`);
        }
        
        // 用户A延时设备
        await this.deviceStatusManager.extendDeviceUsage(this.testDeviceId, 15, 'test_extend_order_a', this.userA);
        
        console.log('✅ 授权用户可以正常控制设备');
    }

    /**
     * 清理测试数据
     */
    async cleanup() {
        console.log('\n清理测试数据...');
        try {
            await this.deviceStatusManager.endDeviceUsage(this.testDeviceId);
            console.log('✅ 测试数据清理完成');
        } catch (error) {
            console.log('⚠️ 清理测试数据时出现错误:', error.message);
        }
    }
}

// 如果直接运行此文件，执行测试
if (require.main === module) {
    const test = new DevicePermissionTest();
    test.runAllTests()
        .then(() => test.cleanup())
        .then(() => {
            console.log('\n🎉 测试完成！');
            process.exit(0);
        })
        .catch((error) => {
            console.error('\n💥 测试失败:', error);
            test.cleanup().finally(() => process.exit(1));
        });
}

module.exports = DevicePermissionTest;